
// 我们把这个类，就叫做我们的顺序表


import java.util.Arrays;

public class MySequentialList {
  // 首先顺序表示一个数组，所以肯定有一个属性是数组
    public int[] array;// 默认值为null
    // usedSize  表示整个数组的有效数据
    public  int usedSize;// 默认值为0 ，不用初始化，用来表示我当前数组的有效元素个数
    // 注意 上面的 array 和 usedSize 都是一个变量，且没有初始化赋值

    // 然后，我们可以写一个构造方法
    public MySequentialList(){
      // 就是说当我们 new 对象的时候， 编译会调用我们写的构造方法
      // 意味着 将初始化 我们的 数组 array，长度为10
      this.array = new int[10];
    }
         // 打印顺序表
           public void display() {
             for (int i = 0; i < this.usedSize; i++) {
               System.out.print(this.array[i] + " ");
             }
             System.out.println();// 换行
          }
         // 获取顺序表的有效长度
          public int size() {
            return this.usedSize;
          }

          // 在 pos 位置新增元素
          public void add(int pos, int data) {
              // 1.
              if(pos<0||pos>this.usedSize){
                  System.out.println("pos的位置不合法！");
                  return;
              }
              // 2.
              dilatation();
              // 3.
              for (int i = this.usedSize-1; i >= pos; i--) {
                  this.array[i+1]=this.array[i];
              }
              // 4.
              this.array[pos] = data;
              this.usedSize++;
          }
          // 扩容
          public void dilatation(){
             if(this.array.length == this.usedSize){
                this.array = Arrays.copyOf(this.array,this.array.length*2);
             }
          }


          // 判定是否包含某个元素
          public boolean contains(int toFind) {
              for (int i = 0; i < this.usedSize; i++) {
                  if(this.array[i] == toFind){
                      return true;
                  }
              }
              return false;
          }
          // 查找某个元素对应的位置
          public int search(int toFind) {
              for (int i = 0; i < this.usedSize; i++) {
                  if(this.array[i]==toFind){
                      return  i;
                  }
              }
            return -1;// 找不到，返回-1.因为数组的下标没有负数
          }
          // 获取 pos 位置的元素
          public int getPos(int pos) {
            if(pos<0||pos>this.usedSize){
                System.out.println("pos的位置不合法!");
                return -1;//其实这里返回-1，不是很合适，我可以通过抛异常来解决这个问题，只不过，现在我们没有这个只是储备
                // 所以我们在写了一句修饰型语言，如果数组里真的有元素 -1.那么打印的结果就只有 -1，而没有修饰语句
            }
            if(isEmpty()){
                System.out.println("顺序表为空，无法寻找对应下标的元素");
                return -1;
            }
              return this.array[pos];
          }
          // 判断是 顺序表是否为空
          public boolean isEmpty(){
               return this.usedSize == 0;
          }


          // 给 pos 位置的元素设为 value
          public void setPos(int pos, int value) {
              if(pos<0||pos>this.usedSize){
                  System.out.println("pos的位置不合法!");
                  return ;
              }
              if(isEmpty()){
                  System.out.println("顺序表为空，无法寻找对应下标的元素");
                  return ;
              }
              this.array[pos]= value;
          }

          //删除第一次出现的关键字key
         public void remove(int toRemove) {
             if(isEmpty()){
                 System.out.println("顺序表为空，你要删除数字不存在！");
             }
             int index = search(toRemove);
             if(index == -1){
                 System.out.println("你要删除数字不存在！");
                 return;
             }
             for (int i = index; i < this.usedSize-1; i++) {
                 this.array[i] = this.array[i+1];
             }
             this.usedSize--;
             //this.array[usedSize]=null; 元素是引用类型 就可以加上该语句
    }



          // 清空顺序表
          public void clear() {
             this.usedSize = 0; // 简单数据可以这么清空

              //  如果数组数据类型是引用类型，那就不能这么做
              // 我们需要将每个元素置为null，将所指对象的空间释放
              // 写法如下：
//              for (int i = 0; i < this.usedSize; i++) {
//                  this.array[i]=null;
//              }

          }
}
